{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Content provided under a Creative Commons Attribution license, CC-BY 4.0; code under BSD 3-Clause license. (c)2014 Lorena A. Barba, Olivier Mesnard. Thanks: NSF for support via CAREER award #1149784."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Source panel method"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We are now getting close to the finish line with *AeroPython*! Our first few lessons introduced the fundamental flow solutions of potential flow, and we quickly learned that using our superposition powers we could get some useful results in aerodynamics. \n",
    "\n",
    "The superposition of a [doublet](03_Lesson03_doublet.ipynb) and a free stream gave the flow around a circular cylinder, and we learned about the *D'Alembert paradox*: the result of zero drag for potential flow around a cylinder. Adding a [vortex](06_Lesson06_vortexLift.ipynb) at the center of the cylinder, we learned about lift and the *Kutta-Joukowski theorem* stating that lift is proportional to circulation: $L=\\rho U \\Gamma$. A most important result!\n",
    "\n",
    "Adding together fundamental solutions of potential flow and seeing what we get when interpreting a dividing streamline as a solid body is often called an *indirect method*. This method goes all the way back to Rankine in 1871! But its applicability is limited because we can't stipulate a geometry and find the flow associated to it.\n",
    "\n",
    "In [Lesson 9](09_Lesson09_flowOverCylinder.ipynb), we learned that it is possible to stipulate first the geometry, and then solve for the source strengths on a panel discretization of the body that makes the flow tangent at the boundary. This is called a *direct method* and it took off in the 1960s with the work of Hess and Smith at Douglas Aircraft Company.\n",
    "\n",
    "A set of panels (line segments in 2D) can represent the surface of any solid body immersed in a potential flow by making the source-sheet strengths such that the normal velocity at each panel is equal to zero. This is a very powerful idea! But you should realize that all the panel strengths are coupled to each other, which is why we end up with a linear system of equations.\n",
    "\n",
    "For an arbitrary geometry, we need to build a set of panels according to some points that define  the geometry. In this lesson, we will read from a file a geometry definition corresponding to a **NACA0012 airfoil**, create a set of panels, and solve for the source-sheet strengths to get flow around the airfoil.\n",
    "\n",
    "*Make sure you have studied [Lesson 9](09_Lesson09_flowOverCylinder.ipynb) carefully before proceeding!* We will not repeat the full mathematical formulation in this notebook, so refer back as needed.\n",
    "\n",
    "First, load our favorite Python libraries, and the `integrate` module from SciPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import math\n",
    "import numpy\n",
    "from scipy import integrate\n",
    "from matplotlib import pyplot\n",
    "# display the figures in the Notebook\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we read the body geometry from a file using the NumPy function [`loadtxt()`](http://docs.scipy.org/doc/numpy/reference/generated/numpy.loadtxt.html). The file comes from the [Airfoil Tools](http://airfoiltools.com/airfoil/details?airfoil=n0012-il) website and it contains a set of coordinates for the standard NACA0012 symmetric profile. We saved the file in the `resources` folder and load it from our local copy.\n",
    "\n",
    "The geometry points get loaded into one NumPy array, so we separate the data into two arrays: `x,y` (for better code readability). The subsequent code will plot the geometry of the airfoil."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAngAAACTCAYAAAAdi2RSAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xl8nNV97/HPT7tla7EWa7XlHezEgMFg08S9Nlto8A2khYLbOEANJq8CDTcNMQm5SUNpWJIWmq0pLjTgCzUJ3FscbKDEsRNK7IKxSbjG2PGizdosybY2S9Zy7h8zmjuSZqSRLY1Gj77v1+u8nmXO88yZwzD+6jybOecQEREREe+IG+sGiIiIiMjIUsATERER8RgFPBERERGPUcATERER8RgFPBERERGPUcATERER8ZiYC3hmdq2ZHTCzQ2b2QIjX/9DM9phZl5nd2O+1W83s9/5ya/RaLSIiIhI7LJbug2dm8cBB4GqgEngXWO2c+zCozkwgHfgysNk595J/fRawG1gCOOA94BLn3IkofgQRERGRMRdrI3iXAYecc0ecc2eATcD1wRWcc6XOud8BPf22/RTwpnOu0R/q3gSujUajRURERGJJrAW8IqAiaLnSv260txURERHxjISxbkA/FmJdpMeQI97WzNYB6wAmTZp0yfTp0yN8i9jR09NDXFys5XNvU59Hn/o8+tTn0ac+j77x3OcHDx6sd87lDlUv1gJeJRCctoqBqmFsu6LftjtCVXTOPQU8BbBkyRK3e/fu4bZzzO3YsYMVK1aMdTMmFPV59KnPo099Hn3q8+gbz31uZmWR1Iu1+PouMM/MZplZEnALsDnCbd8ArjGzqWY2FbjGv05ERERkQompgOec6wLuwRfM9gM/dc7tM7OHzOwzAGZ2qZlVAjcB/2xm+/zbNgJ/iy8kvgs85F8nIiIiMqHE2iFanHNbga391n0jaP5dfIdfQ237DPDMqDZQREREJMbF1AieiIiIiJw7BTwRERERj1HAExEREfEYBTwRERERj1HAExEREfEYBTwRERERj1HAExEREfEYBTwRERERj1HAExEREfEYBTwRERERj1HAExEREfEYBTwRERERj0kY6waIeFlPTw/t7e20trbS1tbG6dOn6ejoGLScOXOGzs5Ourq6hiwjzcxITEwMlISEhD7Lg60PVzcxMZGUlBQmTZoUmCYmJmJmI95+ERHxUcAT6aerq4sTJ05w4sQJGhsbOXHiBE1NTezevZs9e/bQ1NREc3Nzn2lTUxNtbW0DyunTp8f648SkuLg4Jk2aNKD0BsDe0tTUxPPPPx+yTmpqKpMnTyYtLY0pU6YMmE6ZMoX4+Pix/qgiImMi5gKemV0L/CMQD/yLc+7Rfq8nA88BlwANwM3OuVIzmwnsBw74q+5yzn0hWu2W2NTd3U1DQwPHjx+nrq6uz7R3vjfE9U6bm5tHtA3BYSQlJYXk5ORBS1JSEklJSSQkJAxa4uPjR3wUrLu7m66ursAIYmdnZ5/Sf10kdTo7O2lvb+f06dOB0tXVRWtrK62trSPa/v4mTZo0IPQNFgh759PT08nMzCQjIyMwTUlJ0aijiIwbMRXwzCwe+CFwNVAJvGtmm51zHwZVWwuccM7NNbNbgMeAm/2vHXbOXRTVRsuYcM5RX19PRUUFVVVVIUt1dTW1tbU454a1bzNj6tSpfUpGRgYtLS2cd955pKenk5aWRnp6emC+NxikpqYGwlxqaiopKSnExelU1/66uroGhL5QZc+ePcyaNSvka21tbbS2ttLS0kJzc3PIaW/d48ePn3Obk5KSyMjI6BP6+k8Hey09PZ2EhJj6yRURD4u1X5vLgEPOuSMAZrYJuB4IDnjXA3/jn38J+IHpz2rPcc5RXV3NoUOHKCsro6ysjPLy8j7zkR7+zM7OJjc3l2nTppGbmztgPjs7m6ysrECYS09PDxnKduzYwYoVK0b4k05MCQkJgVGzweTk5Jx1nzvnOH36dNjwFy4Y9h52P3XqFKdOneLkyZOcPHmSM2fOBEZ+z1ZaWhpZWVnDLikpKWf9niIyMcVawCsCKoKWK4Gl4eo457rM7BSQ7X9tlpntBZqArzvn3hrl9so5cM5RU1PD/v37OXToUJ9y+PBh2traBt0+MzOT6dOnU1RURGFhYcgybdo0EhMTo/SJJJaYWWBENS8v75z3197eHgh8g03DvdZ7zmZzczNlZWXDeu/U1NQhQ2BOTk6g5ObmMnXqVJ2DKDKB2XAPX40mM7sJ+JRz7g7/8hrgMufcvUF19vnrVPqXD+Mb+WsBpjjnGszsEuDfgY8555pCvM86YB1AXl7eJZs2bRrlTzbyWlpahhz9iBW9h1OPHj0aGIErLS2lrKyMlpaWsNulp6dTVFREQUEB06ZNIy8vr0+ZPHlyFD/F+Opzr/BSn/f09NDW1jbgAp3gUcNw07O5YtrMSEtLG3AIObj0P7SckpJCa2urZ/p8vPDS93y8GM99vnLlyvecc0uGqhdrI3iVwPSg5WKgKkydSjNLADKARudLqh0Azrn3/MFvPrC7/5s4554CngJYsmSJG4+H3WL1cGF3dzcHDhxg7969vP/++4FpQ0NDyPqZmZksWLCA+fPnM3fu3ECZM2cOU6dOjXLrBxerfe5l6nPfH0itra00NjaGLQ0NDTQ0NFBfX8/x48epr6+nsbExcIV3RUXF0G8EJCcnk5aWRnFxcWA0cNq0aYGSl5fXZz7af2R5lb7n0TcR+jzWAt67wDwzmwUcA24B/qxfnc3ArcBO4Ebgl845Z2a5+IJet5nNBuYBR6LX9Inp2LFj7Ny5k127drFr1y727NkT8ty4rKwsFi1axMKFC1m4cCELFixg4cKF5Ofn68pEkUGYWeB8xRkzZkS8XVdXF42NjdTX1/cJfoPNt7W10dHRQX19fUTvkZqaGjb89Z/Pzs7WIWORKIqpgOc/p+4e4A18t0l5xjm3z8weAnY75zYDTwMbzewQ0IgvBAL8IfCQmXUB3cAXnHON0f8U3uWcY9++fWzfvp233nqLnTt3UllZOaBeSUkJixcv5qKLLmLx4sUsXryY4uJiBTmRKEpISAiErEi1tbXx85//nHnz5gUuKOm9nVBdXR21tbV95tva2igtLaW0tHTIfcfFxfUZEczPz6egoCDkdOrUqfq9EDlHMRXwAJxzW4Gt/dZ9I2i+HbgpxHYvAy+PegMnEOccv//979m2bRvbt29nx44dA64gzMjIYOnSpSxbtoxly5Zx2WWXkZ2dHWaPIhLLei9Iufjii4es65yjpaUlZPALNd/Q0BCYH0pSUlKfwBcuDObl5ZGUlDQSH13Ec2Iu4MnYOnPmDL/+9a959dVX2bJlC4cOHerzemFhIStXrmTFihX8wR/8Aeeff77u8yYyAfVexJGWlsacOXOGrN/Z2Ul9fT11dXXU1NRQW1tLdXU1NTU1A6ZNTU2Ul5dTXl4+5H6zs7MjCoMZGRkaFZQJRQFPOH36NFu2bOHFF1/k9ddf73Nla1ZWFldddRVXXHEFK1euZN68efqRFJFhS0xMpKCggIKCAi688MJB67a1tfUJfKFCYO+NzHsvMNm3b9+g+0xJSQkEwMLCwsDtlYqKigKlsLCQtLS0kfzYImNGAW+C6uzs5I033mDTpk288sorfULdokWLuO6661i1ahVLly7V3fdFJKpSU1OZPXs2s2fPHrRed3c39fX1YQNgcDhsaWmJ6HzBtLS0PoGvfwAsKioiPz9fv4sS8/QNnWDKysrYsGEDTz/9NDU1NYH1l156KatXr+aP//iPKSkpGcMWiohEJj4+PnBfzKFGBVtaWgJhr6qqimPHjgWmvaWqqorm5mY++ugjPvroo7D7iouLIy8vL2wA7C06LCxjSQFvAnDO8ctf/pInnniCrVu3Bp7Nev7557NmzRpuvvnmiM6hEREZr6ZMmRK4z2Y4zjlOnDgRNvz1ztfV1VFdXU11dTXvvfde2P2lpqYGQl9xcTHTp08PTHuLLkqT0aKA52HOObZu3crDDz/Mrl27AN/VaTfeeCN33XUXy5cv11+XIiJ+ZhZ49NuiRYvC1uvs7KSmpiZsAOydb2lpCTx+MZyUlBSys7OZP39+IPT1D4GZmZn6rZZhU8DzqLfffpsvfvGLgb8us7Ozue+++7jrrrvIzc0d49aJiIxfiYmJgfA1mKampkDoq6yspKKiIjDtLadOnQrUCWfy5MkDQl//5fT09JH+mDLOKeB5TFVVFV/5yld4/vnnAcjPz+f+++9n3bp14/a5eyIi41F6ejrp6eksWLAgbJ3m5mZefvllCgsL+wS/4CDY0tLCgQMHOHDgwKDvVVxczIwZMygpKaGkpKTPfGFhoZ4kMsEo4HnIyy+/zNq1azl16hTJycmsX7+e9evXk5qaOtZNExGRENLS0pg5c2bY56I65zh16lTI0b/gdU1NTXz44Yd8+OGHIfeTkJBAcXFxIPD1D4AzZswgJSVlFD+pRJsCngd0dHTwpS99iR/96EcAXHfddXz/+99n1qxZY9wyERE5F2ZGZmYmmZmZYc8LdM7R2NhIRUUF5eXllJWVBaa9pba2dsjbxOTl5YUNgCUlJWRmZo7Sp5TRoIA3zrW1tXHDDTfw5ptvkpSUxHe/+13uuecenZArIjJBmBnZ2dlkZ2dz0UUXhazT3t7eJ/T1D4CVlZXU1tZSW1vLO++8E3If6enpYcPfzJkzycvL0789MUQBbxxra2tj1apVbN++nWnTprFlyxaWLFky1s0SEZEYk5KSwvz585k/f37I17u7u6mqqgoZ/npLU1MTH3zwAR988EHIfUyaNImZM2cya9askEUjgNGlgDeO3XfffWzfvp2CggK2bds26Im8IiIi4cTHxw96ZbBzjoaGhrDhr7S0lMbGRvbv38/+/ftD7iMzMzNs+Js5cyaTJk0azY844SjgjVNvvfUWGzZsIDk5mddff13hTkRERo2ZkZOTQ05ODhdffHHIOqdOnaK0tJSjR48GypEjRzh69CilpaWcPHmSvXv3snfv3pDb5+fnhwx/c+bMobi4WFcBD5MC3jjU09PDhg0bAHjssce44IILxrhFIiIy0WVkZHDhhReGfGycc466uro+4S+4lJeXB54dvHPnzgHbJyYmMmvWLGbPns2cOXP6lNmzZ2v0L4SIA56ZvQ38GPipc65jtBpkZtcC/wjEA//inHu03+vJwHPAJUADcLNzrtT/2leBtUA38FfOuTdGq51jadu2bVRUVFBcXMzdd9891s0REREZlJkFnhu8bNmyAa93dXVx7NixkOHv8OHD1NTUcPDgQQ4ePBhy/4WFhX0CX3AAzM7OnpAXfwxnBK8TeBZ40syeBZ5yzoV/GvNZMLN44IfA1UAl8K6ZbXbOBd/YZy1wwjk318xuAR4DbjazhcAtwMeAQuAXZjbfOdc9km2MBVu2bAHg9ttvJyFBg7AiIjK+JSQkBK7IDXVPwNbWVo4cOcKRI0c4fPhwn1JaWkpVVRVVVVW89dZbA7ZNT08fMOKXlpYWhU81tiJOB865FWZ2HnAX8Hngi2b2FvBPwP92znWOQHsuAw45544AmNkm4HogOOBdD/yNf/4l4Afmi+bXA5v8o4tHzeyQf38Dx3rHud7nGoa7HF5ERMRLJk+ezKJFi0LeC7Crq4uKiooBwa83DDY1NYU89++zn/2sp2/uPKzhH+fcAeBL/kOhfwqsA14A6s3sX/GN6h05h/YUARVBy5XA0nB1nHNdZnYKyPav39Vv26JQb2Jm6/xtJy8vjx07dpxDk6Ov90aV5eXl467t41lLS4v6O8rU59GnPo8+9fnISEhI4LzzzmP+/PmB5wBXVVWxf/9+du/eTXl5eZ/6jz76aNgniHjBWR3f84+SbTSzfcA/AH8IfAX4spn9H+Be51zNWew61EFyF2GdSLb1rXTuKeApgCVLlrjx9h/4ggsuYN++fWRmZnr6yxlrduzYof6OMvV59KnPo099Pnzd3d1UVlYOGLXrLU1NTUPu4+tf/7qnT3Ma9iczs0nAauAL+C50+Aj4IvAz4L/jO3z6PHDlWbSnEgi+CU8xUBWmTqWZJQAZQGOE23rCxz72MQD+4z/+g9tuu21sGyMiIjIKWltbKS0tDRngSktL6ewMf2bYlClTBlxt21umT5/Of/7nf3o63MHwrqJdhO/8uz8HJgOvAOudc9uDqm0wsxp8Ye9svAvMM7NZwDF8F038Wb86m4Fb8Z1bdyPwS+ecM7PNwAtm9g/4LrKYB4R+3so4t2bNGr7xjW/w0ksv8Z3vfIeiopBHokVERGJWR0cH5eXlgfvkBV85W1paSl1d3aDb5+fnhw1xOTk5E/LK2WDDia+/xTci9iS+c+2qw9Q7xFle2OA/p+4e4A18t0l5xjm3z8weAnY75zYDT+M7PHwI38jdLf5t95nZT/FdkNEF3O3FK2gBZsyYwfLly/nVr37FnXfeyZYtWyb8F1lERGJL/1uf9A9xVVVVOBfyTCrAd++7kpKSkLc/mT17NpMnT47ipxl/hhPwbgL+fajQ5JzbD6w82wY557YCW/ut+0bQfLu/LaG2/Tvg7872vceTu+++mw8++IDXXnuNRx55hK997Wtj3SQREZlAenp6qKmp6RPcgucrKiro6uoKu31cXBwzZswIPKos+LFls2bNorCwkLi4uCh+Im8Zzm1SXh7Nhsjw5Obm8vTTT/PZz36WBx98kLi4OB544IGxbpaIiHhET08PtbW1lJWVUV5ePiDIlZaW0tEx+HMPCgoKBgS33vnp06eTmJgYpU8z8Xj7DEOPu+GGG3j66ae54447+OpXv8qxY8f47ne/S3Jy8lg3TUREYlxbWxsVFRWUl5cHQlzwfEVFxaAXMgDk5OSEHYErKSnx9H3mYp0C3jj3F3/xFyQmJrJ27Vp+8IMf8Pbbb/Piiy8yb968sW6aiIiMkd5nv/YPbcHL9fX1Q+4nNzeXGTNmMGPGDEpKSvqEuJkzZ06IJ0KMVwp4HrBmzRoWLFjAzTffzN69e7ngggtYv34969ev1wOYRUQ8qL29ncrKypAjb71lqMOniYmJTJ8+nZKSkj4hrnd++vTppKamRukTyUhTwPOIJUuWsGfPHu699142btzIt771LX7yk5/w6KOPctNNNxEfHz/WTRQRkQh0dnZSVVVFZWVln9J7OLW8vJza2toh95OVlRUyuPUu5+Xl6SIGD1PA85CMjAyee+457rzzTu69915++9vfsnr1ar71rW/xta99jdWrV3v+xo4iIrGso6ODY8eO9Qluu3bt4nvf+15guaamZtDbhwDEx8dTXFw86OibDp9ObPrX3oOWL1/O7t27eeaZZ/j2t7/NRx99xOc//3m++c1v8pd/+Zfcdttt5OTkjHUzRUQ85fTp0wNG3fqXoW7eC2BmFBYWUlxcHCjTp0+nqKgoEOQKCgp0ZEYGpYDnUQkJCaxbt47bb7+d559/nkceeYSDBw9y//338+CDD3LjjTdy1113sXz5ct0kWURkED09PRw/fpyqqqoBJXg0rqGhYch9xcfHDwhv7e3trFy5MrCcn5+v24fIOVPA87jExERuu+021qxZw2uvvcaPf/xjtm7dygsvvMALL7xASUkJN998M7fccgsXXXSRwp6ITBjOORobG0MGt+BSXV1Nd/fQD0ZKTEykqKioT3jrPwqXl5c3YORtx44drFixYpQ+pUxUCngTRHx8PKtWrWLVqlWUlZWxYcMGnn32WcrKynj88cd5/PHHmT9/Pn/yJ3/CqlWrWLp0qYb/RWRccs7R1NQ0ZHCrqqrizJkzEe0zOzubwsLCkKU3wE2bNk0XLUjMUMCbgEpKSnj44Yd56KGH+M1vfsOmTZv42c9+xsGDB3nkkUd45JFHyM7O5tOf/jTXXXcdV199NVlZWWPdbBGZ4Lq6ujh+/Dg1NTXU1tb2mdbU1PQJbm1tbRHtMyMjI2xw6y35+fm6Ya+MOwp4E1hcXByf/OQn+eQnP8mTTz7Jjh07+PnPf86rr77KkSNH2LhxIxs3bsTMuPDCC1m5ciVXXHEFy5cvJyMjY6ybLyIe0NPTQ0NDQ5+gFm6+vr5+yKtLe6WmplJUVDRocCsoKNAD68WzFPAE8F2UcdVVV3HVVVfx5JNPcuDAAV599VW2bNnCb37zG95//33ef/99nnjiCeLi4rj44ou5/PLLufzyy1m2bBkzZ87U+XsiAvgOkZ48eTKi0FZXVxfR+W3gu7o0NzeX/Px88vLyyM/PD8zn5eX1CXRpaWn6TZIJTQFPBjAzzj//fM4//3y+/OUv09bWxs6dO9m+fTvbt2/nnXfeYffu3ezevZvvf//7AOTl5bFs2TKWLVvG4sWLueiii8jLyxvjTyIiI6W9vZ3jx49TV1fH8ePHQ87X1tYGwluk57YBTJ06NWRo6z+fm5ure3mKRChm/k8xsyzgRWAmUAr8qXPuRIh6twJf9y8+7Jx71r9+B1AAnPa/do1zbugbDsmQUlNTufLKK7nyyisBaGlpYdeuXX1KbW0tr7zyCq+88kpgu4KCgkDYW7x4MR//+MeZM2eOLv8XiQHhAtt7773Hxo0bB6xvaWkZ1v7T0tIiCm3Tpk0jOTl5lD6lyMQVMwEPeADY5px71Mwe8C+vD67gD4HfBJYADnjPzDYHBcE/d87tjmajJ6IpU6YEDueC73DM4cOH2bVrF++8807gcG51dTXV1dVs3bo1sG1iYiLz589n4cKFgbJgwQLmzp2r5+aKnKW2tjYaGhqor6+noaEhUMItHz9+fNiBLTExkdzcXHJzc5k2bVrI+d7QlpeXp2eYioyxWAp41wMr/PPPAjvoF/CATwFvOucaAczsTeBa4N+i00QJxcyYO3cuc+fO5XOf+xzgO3H6yJEj7N27l7179/L++++zf/9+SktL2bdvH/v27Ruwn+Li4sB+esucOXOYNWuWLuqQCaGzs5OTJ09y4sQJTpw40SecDRbY2tvbh/1e4QJbS0sLS5cuHbA+IyND57SJjCOxFPDynHPVAM65ajObFqJOEVARtFzpX9frX82sG3gZ3+HbyC63khEXFxcXCGk33XRTYH1LSwsHDhzgww8/DJT9+/dz9OjRwN3gd+zYMWB/6enplJSU9Cm9z1wsKioiPz+fpKSkKH5CkdDa29sDAS04rEWybrijar2Sk5PJzs4mJyeH7OzsQAm3nJOTEzaw6aa7It5g0cxAZvYLID/ESw8CzzrnMoPqnnDOTe23/f1AsnPuYf/y/wTanHN/b2ZFzrljZpaGL+D9L+fcc2HasQ5YB5CXl3fJpk2bRuLjRVVLSwtTpkwZ62aMmO7ubmprazl27Fig9D4GqKamho6OjiH3kZmZSVZWVp9/xLKyspg6dSoZGRlMnTqVzMxM0tLSzupmpF7r8/Egmn3e09PD6dOnaWtro62tjdbW1pDT/utaWlpoaWmhubmZlpaWYV1c0F9cXBxTpkwJlPT0dDIyMkJOe0tGRgYpKSkjNrqm73n0qc+jbzz3+cqVK99zzi0Zql5UR/Ccc1eFe83Mas2swD96VwCEukCikv9/GBegGN+hXJxzx/zTZjN7AbgMCBnwnHNPAU8BLFmyxI3Hv1Yn0l/ZzjkaGhooKyujrKyM8vLyPvPV1dXU1NRw8uRJTp48yZEjRwbdX1xcHDk5OYFDUFlZWYEg2DvtP5+RkcGePXsmTJ/HinDf856enkDACg5b4ZZbW1tpbm6mqakpbGlubh6RNicmJga+N71/VAy2HLzubP/4GEkT6bclVqjPo28i9HksHaLdDNwKPOqfvhKizhvAt82sd2TvGuCrZpYAZDrn6s0sEVgF/CIKbZYoMDNycnLIycnhkksuCVmnu7s75MPAq6ur+1wpWFdXx8mTJ6mrq6Ouri7kuYCDSUlJIT09nbS0tMAISu/85MmTSU1NHVCC16ekpJCcnDxkGet/5IfinKOrq4uOjg7OnDlDR0fHsMpg2wQHtGPHjpGYmDggsJ3NOWeRmDx5cp/RseBRslDre0twUEtNTdW5aiIy5mIp4D0K/NTM1gLlwE0AZrYE+IJz7g7nXKOZ/S3wrn+bh/zrJgNv+MNdPL5wtyH6H0HGSnx8fOD2CxdffPGgdc+cOUN9fX0g8DU2NgbOhQo33zvK097eTnt7O3V1o3sHHjMjPj6euLg44uPj+8z3n0ayDnwhuKen56yn/deNtd7w3Bugh5oPDuWhSlpamp6/LCKeETMBzznXAFwZYv1u4I6g5WeAZ/rVaQVCD+2I9JOUlBS42/1wbN++naVLlwYO5wVPm5qaAudn9T9fK3jd6dOnIxrd6h0hi2VxcXERjUYOtwSHsoMHD/KJT3xiQFhLSUmJ+VFOEZGxFDMBTyTWmVngUGt+fqhrhUaGc67PiFmoEbXBRttCrTOzsCOAkUzDrRttqampXHrppaP+PiIiXqOAJxJjeg/PxsfH66kfIiJyVnSMQ0RERMRjFPBEREREPEYBT0RERMRjFPBEREREPEYBT0RERMRjFPBEREREPEYBT0RERMRjFPBEREREPEYBT0RERMRjFPBEREREPEYBT0RERMRjFPBEREREPCZmAp6ZZZnZm2b2e/90aph6r5vZSTN7td/6WWb2X/7tXzSzpOi0XERERCS2xEzAAx4Atjnn5gHb/MuhfAdYE2L9Y8AT/u1PAGtHpZUiIiIiMS6WAt71wLP++WeBG0JVcs5tA5qD15mZAVcALw21vYiIiIjXxVLAy3POVQP4p9OGsW02cNI51+VfrgSKRrh9IiIiIuNCQjTfzMx+AeSHeOnBc911iHVukHasA9b5F1vM7MA5vv9YyAHqx7oRE4z6PPrU59GnPo8+9Xn0jec+L4mkUlQDnnPuqnCvmVmtmRU456rNrACoG8au64FMM0vwj+IVA1WDtOMp4Klh7D/mmNlu59ySsW7HRKI+jz71efSpz6NPfR59E6HPY+kQ7WbgVv/8rcArkW7onHPAduDGs9leRERExEtiKeA9ClxtZr8HrvYvY2ZLzOxfeiuZ2VvAz4ArzazSzD7lf2k98CUzO4TvnLyno9p6ERERkRgR1UO0g3HONQBXhli/G7gjaHl5mO2PAJcXR69RAAAFRElEQVSNWgNjz7g+xDxOqc+jT30eferz6FOfR5/n+9x8RzdFRERExCti6RCtiIiIiIwABbwYZ2bXmtkBMztkZgOe7mFmyf5Hsx3yP6ptZvRb6S0R9PmXzOxDM/udmW0zs4guWZfwhurzoHo3mpkzM09f/RYNkfS5mf2p/7u+z8xeiHYbvSaC35YZZrbdzPb6f18+PRbt9Aoze8bM6szs/4Z53czse/7/Hr8zs4uj3cbRpIAXw8wsHvgh8EfAQmC1mS3sV20tcMI5Nxd4At8j2+QsRdjne4ElzrkL8D095fHottJbIuxzzCwN+Cvgv6LbQu+JpM/NbB7wVeATzrmPAfdFvaEeEuH3/OvAT51zi4FbgB9Ft5We8xPg2kFe/yNgnr+sA/4pCm2KGgW82HYZcMg5d8Q5dwbYhO+RbsGCH/H2Er6ri0Pd+FkiM2SfO+e2O+fa/Iu78N13Uc5eJN9zgL/FF6bbo9k4j4qkz+8EfuicOwHgnBvOvUlloEj63AHp/vkMBrmfqwzNOfdroHGQKtcDzzmfXfjup1sQndaNPgW82FYEVAQth3oEW6CO/ybPp/DdJkbOTiR9Hmwt8Nqotsj7huxzM1sMTHfOvRrNhnlYJN/z+cB8M3vbzHaZ2WAjITK0SPr8b4DPmVklsBW4NzpNm7CG+3s/rsTMbVIkpEgewTasx7TJkCLuTzP7HLAE+G+j2iLvG7TPzSwO3+kHt0WrQRNAJN/zBHyHrlbgG6V+y8w+7pw7Ocpt86pI+nw18BPn3N+b2eXARn+f94x+8yYkT//7qRG82FYJTA9aDvUItkAdM0vAN6w/2JC0DC6SPsfMrsL3DOXPOOc6otQ2rxqqz9OAjwM7zKwUWAZs1oUW5yTS35ZXnHOdzrmjwAF8gU/OTiR9vhb4KYBzbieQgu+ZqTI6Ivq9H68U8GLbu8A8M5tlZkn4Trrd3K9O8CPebgR+6XRzw3MxZJ/7Dxf+M75wp/OSzt2gfe6cO+Wcy3HOzXTOzcR33uNn/DdBl7MTyW/LvwMrAcwsB98h2yNRbaW3RNLn5fhv+G9mC/AFvONRbeXEshn4vP9q2mXAKedc9Vg3aqToEG0Mc851mdk9wBtAPPCMc26fmT0E7HbObcb3SLaN/ke0NeL70ZCzFGGffweYAvzMfz1LuXPuM2PW6HEuwj6XERRhn78BXGNmHwLdwP3+Jw7JWYiwz/8a2GBm/wPfocLb9Af72TOzf8N3ikGO/7zGbwKJAM65H+M7z/HTwCGgDbh9bFo6OvQkCxERERGP0SFaEREREY9RwBMRERHxGAU8EREREY9RwBMRERHxGAU8EREREY9RwBMRERHxGAU8EREREY9RwBMRERHxGAU8EZFzZGaTzewjM3vHzBKD1l9jZj1mdvdYtk9EJh49yUJEZAT4n1G8C3jCOfeAmU0Dfge8o0fZiUi0KeCJiIwQ/zNE/x64BvgysAi40DlXP6YNE5EJRwFPRGSEmJkBW4ArgCTgaufctrFtlYhMRDoHT0RkhDjfX8wbgWTgtwp3IjJWFPBEREaImeUDTwJ7gAvN7Itj3CQRmaAU8ERERoD/8OyzwBnganxB7zEzu2BMGyYiE5LOwRMRGQFm9tfA48AVzrlfmVkSvqtqk4ElzrnTY9pAEZlQNIInInKO/LdI+TbwiHPuVwDOuTPAamAm8A9j1zoRmYg0giciIiLiMRrBExEREfEYBTwRERERj1HAExEREfEYBTwRERERj1HAExEREfEYBTwRERERj1HAExEREfEYBTwRERERj1HAExEREfGY/wcGO1ReCcYaXgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# read of the geometry from a data file\n",
    "naca_filepath = os.path.join('resources', 'naca0012.dat')\n",
    "with open (naca_filepath, 'r') as file_name:\n",
    "    x, y = numpy.loadtxt(file_name, dtype=float, delimiter='\\t', unpack=True)\n",
    "\n",
    "# plot the geometry\n",
    "width = 10\n",
    "pyplot.figure(figsize=(width, width))\n",
    "pyplot.grid()\n",
    "pyplot.xlabel('x', fontsize=16)\n",
    "pyplot.ylabel('y', fontsize=16)\n",
    "pyplot.plot(x, y, color='k', linestyle='-', linewidth=2)\n",
    "pyplot.axis('scaled', adjustable='box')\n",
    "pyplot.xlim(-0.1, 1.1)\n",
    "pyplot.ylim(-0.1, 0.1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Discretization into panels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like in [Lesson 9](09_Lesson09_flowOverCylinder.ipynb), we will create a discretization of the body geometry into panels (line segments in 2D). A panel's attributes are: its starting point, end point and mid-point, its length and its orientation. See the following figure for the nomenclature used in the code and equations below.\n",
    "\n",
    "<img src=\"./resources/panelSketch.png\" width=\"400\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can modify the `Panel` class from our previous notebook slightly, to work better for our study of flow over an airfoil. The only difference is that we identify points on the top or bottom surfaces with the words `upper` and `lower`, which is only used later for plotting results with different colors for the top and bottom surfaces of the profile."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Panel:\n",
    "    \"\"\"\n",
    "    Contains information related to a panel.\n",
    "    \"\"\"\n",
    "    def __init__(self, xa, ya, xb, yb):\n",
    "        \"\"\"\n",
    "        Initializes the panel.\n",
    "        \n",
    "        Sets the end-points and calculates the center, length,\n",
    "        and angle (with the x-axis) of the panel.\n",
    "        Defines if the panel is on the lower or upper surface of the geometry.\n",
    "        Initializes the source-sheet strength, tangential velocity,\n",
    "        and pressure coefficient to zero.\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        xa: float\n",
    "            x-coordinate of the first end-point.\n",
    "        ya: float\n",
    "            y-coordinate of the first end-point.\n",
    "        xb: float\n",
    "            x-coordinate of the second end-point.\n",
    "        yb: float\n",
    "            y-coordinate of the second end-point.\n",
    "        \"\"\"\n",
    "        self.xa, self.ya = xa, ya\n",
    "        self.xb, self.yb = xb, yb\n",
    "        \n",
    "        self.xc, self.yc = (xa + xb) / 2, (ya + yb) / 2  # control-point (center-point)\n",
    "        self.length = math.sqrt((xb - xa)**2 + (yb - ya)**2)  # length of the panel\n",
    "        \n",
    "        # orientation of the panel (angle between x-axis and panel's normal)\n",
    "        if xb - xa <= 0.0:\n",
    "            self.beta = math.acos((yb - ya) / self.length)\n",
    "        elif xb - xa > 0.0:\n",
    "            self.beta = math.pi + math.acos(-(yb - ya) / self.length)\n",
    "        \n",
    "        # location of the panel\n",
    "        if self.beta <= math.pi:\n",
    "            self.loc = 'upper'\n",
    "        else:\n",
    "            self.loc = 'lower'\n",
    "        \n",
    "        self.sigma = 0.0  # source strength\n",
    "        self.vt = 0.0  # tangential velocity\n",
    "        self.cp = 0.0  # pressure coefficient"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For the circular cylinder, the discretization into panels was really easy. This is the part that gets more complicated when you want to compute the flow around a general geometry, while the solution part is effectively the same as in [Lesson 9](09_Lesson09_flowOverCylinder.ipynb).\n",
    "\n",
    "The function below will create the panels from the geometry data that was read from a file. It is better to have small panels near the leading-edge and the trailing edge, where the curvature is large. One method to get a non uniform distribution around the airfoil is to first discretize a circle with diameter equal to the airfoil's chord, with the leading edge and trailing edge touching the circle at a node, as shown in the following sketch.\n",
    "\n",
    "<img src=\"./resources/naca0012_in_circle.png\" width=\"300\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then, we store the $x$-coordinates of the circle points, `x_circle`, which will also be the $x$-coordinates of the panel nodes, `x`, and project the $y$-coordinates of the circle points onto the airfoil by interpolation. We end up with a node distribution on the airfoil that is refined near the leading edge and the trailing edge. It will look like this:\n",
    "\n",
    "<img src=\"./resources/naca0012_discretized_in_circle.png\" width=\"300\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With the discretization method just described, the function `define_panels()` returns an array of objects, each an instance of the class `Panel` and containing all information about a panel, given the desired number of panels and the set of body coordinates.\n",
    "\n",
    "A few remarks about the implementation of the function `define_panels()`:\n",
    "\n",
    "* we just need to compute the $x$-coordinates of the circle (`x_circle`) since the $y$-coordinates of the panel nodes will be computed by interpolation;\n",
    "* we create a circle with `N+1` points, but the first and last points coincide;\n",
    "* we extend our NumPy arrays by adding an extra value that is equal to the first one; thus we don't have to do anything special with the value `x[i+1]` in the different loops;\n",
    "* the *while*-loop is used to find two consecutive points, (`x[I]`,`y[I]`) and (`x[I+1]`,`y[I+1]`), on the foil such that the interval [`x[I]`,`x[I+1]`] contains the value `x_ends[i]`; we use the keyword `break` to get out of the loop;\n",
    "* once the two points have been identified, the value `y_ends[i]` is computed by interpolation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def define_panels(x, y, N=40):\n",
    "    \"\"\"\n",
    "    Discretizes the geometry into panels using the 'cosine' method.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    x: 1D array of floats\n",
    "        x-coordinate of the points defining the geometry.\n",
    "    y: 1D array of floats\n",
    "        y-coordinate of the points defining the geometry.\n",
    "    N: integer, optional\n",
    "        Number of panels;\n",
    "        default: 40.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    panels: 1D Numpy array of Panel objects\n",
    "        The discretization of the geometry into panels.\n",
    "    \"\"\"\n",
    "    R = (x.max() - x.min()) / 2  # radius of the circle\n",
    "    x_center = (x.max() + x.min()) / 2  # x-coord of the center\n",
    "    # define x-coord of the circle points\n",
    "    x_circle = x_center + R * numpy.cos(numpy.linspace(0.0, 2 * math.pi, N + 1))\n",
    "    \n",
    "    x_ends = numpy.copy(x_circle)  # projection of the x-coord on the surface\n",
    "    y_ends = numpy.empty_like(x_ends)  # initialization of the y-coord Numpy array\n",
    "\n",
    "    x, y = numpy.append(x, x[0]), numpy.append(y, y[0])  # extend arrays using numpy.append\n",
    "    \n",
    "    # computes the y-coordinate of end-points\n",
    "    I = 0\n",
    "    for i in range(N):\n",
    "        while I < len(x) - 1:\n",
    "            if (x[I] <= x_ends[i] <= x[I + 1]) or (x[I + 1] <= x_ends[i] <= x[I]):\n",
    "                break\n",
    "            else:\n",
    "                I += 1\n",
    "        a = (y[I + 1] - y[I]) / (x[I + 1] - x[I])\n",
    "        b = y[I + 1] - a * x[I + 1]\n",
    "        y_ends[i] = a * x_ends[i] + b\n",
    "    y_ends[N] = y_ends[0]\n",
    "    \n",
    "    panels = numpy.empty(N, dtype=object)\n",
    "    for i in range(N):\n",
    "        panels[i] = Panel(x_ends[i], y_ends[i], x_ends[i + 1], y_ends[i + 1])\n",
    "    \n",
    "    return panels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can use this function, calling it with a desired number of panels whenever we execute the cell below. We also plot the resulting geometry."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "N = 40                           # number of panels\n",
    "panels = define_panels(x, y, N)  # discretizes of the geometry into panels\n",
    "\n",
    "# plot the geometry and the panels\n",
    "width = 10\n",
    "pyplot.figure(figsize=(width, width))\n",
    "pyplot.grid()\n",
    "pyplot.xlabel('x', fontsize=16)\n",
    "pyplot.ylabel('y', fontsize=16)\n",
    "pyplot.plot(x, y, color='k', linestyle='-', linewidth=2)\n",
    "pyplot.plot(numpy.append([panel.xa for panel in panels], panels[0].xa),\n",
    "            numpy.append([panel.ya for panel in panels], panels[0].ya),\n",
    "            linestyle='-', linewidth=1, marker='o', markersize=6, color='#CD2305')\n",
    "pyplot.axis('scaled', adjustable='box')\n",
    "pyplot.xlim(-0.1, 1.1)\n",
    "pyplot.ylim(-0.1, 0.1);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Freestream conditions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The NACA0012 airfoil will be immersed in a uniform flow with velocity $U_\\infty$ and an angle of attack $\\alpha=0$. Even though it may seem like overkill to create a class for the freestream, we'll do it anyway. When creating a class, one is expecting to also create several instances of its objects. Here, we just have one freestream, so why define a class? Well, it makes the code more readable and does not block the programmer from using the variable names `u_inf` and `alpha` for something else outside of the class.\n",
    "Also, every time we need the freestream condition as input to a function, we will just have to pass the object as an argument and not all the attributes of the freestream."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Freestream:\n",
    "    \"\"\"\n",
    "    Freestream conditions.\n",
    "    \"\"\"\n",
    "    def __init__(self, u_inf=1.0, alpha=0.0):\n",
    "        \"\"\"\n",
    "        Sets the freestream speed and angle (with the x-axis).\n",
    "        \n",
    "        Parameters\n",
    "        ----------\n",
    "        u_inf: float, optional\n",
    "            Freestream speed;\n",
    "            default: 1.0.\n",
    "        alpha: float, optional\n",
    "            Angle of attack in degrees;\n",
    "            default: 0.0.\n",
    "        \"\"\"\n",
    "        self.u_inf = u_inf\n",
    "        self.alpha = numpy.radians(alpha)  # degrees --> radians"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define and creates the object freestream\n",
    "u_inf = 1.0                            # freestream spee\n",
    "alpha = 0.0                            # angle of attack (in degrees)\n",
    "freestream = Freestream(u_inf, alpha)  # instantiation of the object freestream"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Flow tangency boundary condition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Enforcing the flow-tangency condition on each *control point* approximately makes the body geometry correspond to a dividing streamline (and the approximation improves if we represented the body with more and more panels). So, for each panel $i$, we make $u_n=0$ at $(x_{c_i},y_{c_i})$, which leads to the equation derived in the previous lesson:\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "u_{n_i} = \\frac{\\partial}{\\partial n_i}\\left\\lbrace \\phi\\left(x_{c_i},y_{c_i}\\right) \\right\\rbrace = 0\n",
    "\\end{equation}\n",
    "$$\n",
    "\n",
    "i.e.\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "\\begin{split}\n",
    "0 = & U_\\infty \\cos\\beta_i + \\frac{\\sigma_i}{2} \\\\\n",
    "& + \\sum_{j=1,j\\neq i}^{N_p} \\frac{\\sigma_j}{2\\pi} \\int \\frac{\\left(x_{c_i}-x_j(s_j)\\right) \\cos\\beta_i + \\left(y_{c_i}-y_j(s_j)\\right) \\sin\\beta_i}{\\left(x_{c_i}-x_j(s)\\right)^2 + \\left(y_{c_i}-y_j(s)\\right)^2} {\\rm d}s_j\n",
    "\\end{split}\n",
    "\\end{equation}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the equation above, we calculate the derivative of the potential in the normal direction to enforce the flow tangency condition on each panel. But later, we will have to calculate the derivative in the tangential direction to compute the surface pressure coefficient. And, when we are interested in plotting the velocity field onto a mesh, we will have to calculate the derivative in the $x$- and $y$-direction.\n",
    "\n",
    "Therefore the function below is similar to the one implemented in [Lesson 9](09_Lesson09_flowOverCylinder.ipynb) to obtain the integrals along each panel, but we've generalized it to adapt to the direction of derivation (by means of two new arguments, `dxdz` and `dydz`, which respectively represent the value of $\\frac{\\partial x_{c_i}}{\\partial z_i}$ and $\\frac{\\partial y_{c_i}}{\\partial z_i}$, $z_i$ being the desired direction).\n",
    "\n",
    "Moreover, the function is also more general in the sense of allowing any evaluation point, not just a control point on a panel (the argument `p_i` has been replaced by the coordinates `x` and `y` of the control-point, and `p_j` has been replaced with `panel`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def integral(x, y, panel, dxdz, dydz):\n",
    "    \"\"\"\n",
    "    Evaluates the contribution of a panel at one point.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    x: float\n",
    "        x-coordinate of the target point.\n",
    "    y: float\n",
    "        y-coordinate of the target point.\n",
    "    panel: Panel object\n",
    "        Source panel which contribution is evaluated.\n",
    "    dxdz: float\n",
    "        Derivative of x in the z-direction.\n",
    "    dydz: float\n",
    "        Derivative of y in the z-direction.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    Integral over the panel of the influence at the given target point.\n",
    "    \"\"\"\n",
    "    def integrand(s):\n",
    "        return (((x - (panel.xa - math.sin(panel.beta) * s)) * dxdz +\n",
    "                 (y - (panel.ya + math.cos(panel.beta) * s)) * dydz) /\n",
    "                ((x - (panel.xa - math.sin(panel.beta) * s))**2 +\n",
    "                 (y - (panel.ya + math.cos(panel.beta) * s))**2) )\n",
    "    return integrate.quad(integrand, 0.0, panel.length)[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Building the linear system"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we build and solve the linear system of equations of the form\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "[A][\\sigma] = [b]\n",
    "\\end{equation}\n",
    "$$\n",
    "\n",
    "In building the matrix, below, we call the `integral()` function with the correct values for the last parameters: $\\cos \\beta_i$ and $\\sin\\beta_i$, corresponding to a derivative in the normal direction.\n",
    "\n",
    "Finally, we use `linalg.solve()` from NumPy to solve the system and find the strength of each panel."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def build_matrix(panels):\n",
    "    \"\"\"\n",
    "    Builds the source matrix.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    panels: 1D array of Panel object\n",
    "        The source panels.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    A: 2D Numpy array of floats\n",
    "        The source matrix (NxN matrix; N is the number of panels).\n",
    "    \"\"\"\n",
    "    N = len(panels)\n",
    "    A = numpy.empty((N, N), dtype=float)\n",
    "    numpy.fill_diagonal(A, 0.5)\n",
    "    \n",
    "    for i, p_i in enumerate(panels):\n",
    "        for j, p_j in enumerate(panels):\n",
    "            if i != j:\n",
    "                A[i, j] = 0.5 / math.pi * integral(p_i.xc, p_i.yc, p_j,\n",
    "                                                   math.cos(p_i.beta),\n",
    "                                                   math.sin(p_i.beta))\n",
    "    \n",
    "    return A\n",
    "\n",
    "def build_rhs(panels, freestream):\n",
    "    \"\"\"\n",
    "    Builds the RHS of the linear system.\n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    panels: 1D array of Panel objects\n",
    "        The source panels.\n",
    "    freestream: Freestream object\n",
    "        The freestream conditions.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    b: 1D Numpy array of floats\n",
    "        RHS of the linear system.\n",
    "    \"\"\"\n",
    "    b = numpy.empty(len(panels), dtype=float)\n",
    "    \n",
    "    for i, panel in enumerate(panels):\n",
    "        b[i] = -freestream.u_inf * math.cos(freestream.alpha - panel.beta)\n",
    "    \n",
    "    return b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = build_matrix(panels)           # compute the singularity matrix\n",
    "b = build_rhs(panels, freestream)  # compute the freestream RHS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# solve the linear system\n",
    "sigma = numpy.linalg.solve(A, b)\n",
    "\n",
    "for i, panel in enumerate(panels):\n",
    "    panel.sigma = sigma[i]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Surface pressure coefficient"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "From Bernoulli's equation, the pressure coefficient on the $i$-th panel is\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "C_{p_i} = 1-\\left(\\frac{u_{t_i}}{U_\\infty}\\right)^2\n",
    "\\end{equation}\n",
    "$$\n",
    "\n",
    "where $u_{t_i}$ is the tangential component of the velocity at the center point of the $i$-th panel,\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "\\begin{split}\n",
    "u_{t_i} = & -U_\\infty \\sin\\beta_i \\\\\n",
    "& + \\sum_{j=1}^{N_p} \\frac{\\sigma_j}{2\\pi} \\int \\frac{\\left(x_{c_i}-x_j(s_j)\\right) \\frac{\\partial x_{c_i}}{\\partial t_i} + \\left(y_{c_i}-y_j(s_j)\\right) \\frac{\\partial y_{c_i}}{\\partial t_i}}{\\left(x_{c_i}-x_j(s)\\right)^2 + \\left(y_{c_i}-y_j(s)\\right)^2} {\\rm d}s_j\n",
    "\\end{split}\n",
    "\\end{equation}\n",
    "$$\n",
    "\n",
    "with\n",
    "\n",
    "$$\n",
    "\\begin{equation}\n",
    "\\frac{\\partial x_{c_i}}{\\partial t_i} = -\\sin\\beta_i \\quad\\text{and} \\quad \\frac{\\partial y_{c_i}}{\\partial t_i} = \\cos\\beta_i\n",
    "\\end{equation}\n",
    "$$\n",
    "\n",
    "Notice that below we call the function `integral()` with different arguments: $-\\sin\\beta_i$ and $\\cos\\beta_i$ to get the derivation in the tangential direction."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_tangential_velocity(panels, freestream):\n",
    "    \"\"\"\n",
    "    Computes the tangential velocity on the surface of the panels.\n",
    "    \n",
    "    Parameters\n",
    "    ---------\n",
    "    panels: 1D array of Panel objects\n",
    "        The source panels.\n",
    "    freestream: Freestream object\n",
    "        The freestream conditions.\n",
    "    \"\"\"\n",
    "    N = len(panels)\n",
    "    A = numpy.empty((N, N), dtype=float)\n",
    "    numpy.fill_diagonal(A, 0.0)\n",
    "    \n",
    "    for i, p_i in enumerate(panels):\n",
    "        for j, p_j in enumerate(panels):\n",
    "            if i != j:\n",
    "                A[i, j] = 0.5 / math.pi * integral(p_i.xc, p_i.yc, p_j,\n",
    "                                                   -math.sin(p_i.beta),\n",
    "                                                   math.cos(p_i.beta))\n",
    "    \n",
    "    b = freestream.u_inf * numpy.sin([freestream.alpha - panel.beta \n",
    "                                      for panel in panels])\n",
    "    \n",
    "    sigma = numpy.array([panel.sigma for panel in panels])\n",
    "    \n",
    "    vt = numpy.dot(A, sigma) + b\n",
    "    \n",
    "    for i, panel in enumerate(panels):\n",
    "        panel.vt = vt[i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# compute the tangential velocity at the center-point of each panel\n",
    "get_tangential_velocity(panels, freestream)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_pressure_coefficient(panels, freestream):\n",
    "    \"\"\"\n",
    "    Computes the surface pressure coefficients on the panels.\n",
    "    \n",
    "    Parameters\n",
    "    ---------\n",
    "    panels: 1D array of Panel objects\n",
    "        The source panels.\n",
    "    freestream: Freestream object\n",
    "        The freestream conditions.\n",
    "    \"\"\"\n",
    "    for panel in panels:\n",
    "        panel.cp = 1.0 - (panel.vt / freestream.u_inf)**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# computes the surface pressure coefficients\n",
    "get_pressure_coefficient(panels, freestream)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Theoretical solution"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is a classical method to obtain the theoretical characteristics of airfoils, known as *Theodorsen's method*. It uses the Joukowski transformation but is able to deal with any airfoil by an additional transformation between a \"near circle\" and a circle. The method is hairy indeed! But the resulting values of pressure coefficient are provided for some airfoils in table form in the 1945 [NACA Report No.824](http://ntrs.nasa.gov/archive/nasa/casi.ntrs.nasa.gov/19930090976.pdf), available from the NASA web server (see p. 71). \n",
    "\n",
    "The values of $(u/U_{\\infty})^2$ are given for several stations along the chord length. We transcribed them here, saving them into an array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.    0.64  1.01  1.241 1.378 1.402 1.411 1.411 1.399 1.378 1.35  1.288\n",
      " 1.228 1.166 1.109 1.044 0.956 0.906 0.   ]\n"
     ]
    }
   ],
   "source": [
    "voverVsquared=numpy.array([0.0, 0.64, 1.01, 1.241, 1.378, 1.402, 1.411, 1.411,\n",
    "                           1.399, 1.378, 1.35, 1.288, 1.228, 1.166, 1.109, 1.044,\n",
    "                           0.956, 0.906, 0.0])\n",
    "print(voverVsquared)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.     0.005  0.0125 0.025  0.05   0.075  0.1    0.15   0.2    0.25\n",
      " 0.3    0.4    0.5    0.6    0.7    0.8    0.9    0.95   1.    ]\n"
     ]
    }
   ],
   "source": [
    "xtheo=numpy.array([0.0, 0.5, 1.25, 2.5, 5.0, 7.5, 10.0, 15.0, 20.0, 25.0, 30.0,\n",
    "                   40.0, 50.0, 60.0, 70.0, 80.0, 90.0, 95.0, 100.0])\n",
    "xtheo /= 100\n",
    "print(xtheo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### And plot the result!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We will use the values from the NACA report (also given in the book by Abbot and von Doenhoff, [\"Theory of Wing Sections,\"](http://books.google.com/books/about/Theory_of_Wing_Sections_Including_a_Summ.html?id=DPZYUGNyuboC) 1949) to visually compare the pressure distribution with the result of our source panel method. Let's see how it looks!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x432 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the surface pressure coefficient\n",
    "pyplot.figure(figsize=(10, 6))\n",
    "pyplot.grid()\n",
    "pyplot.xlabel('x', fontsize=16)\n",
    "pyplot.ylabel('$C_p$', fontsize=16)\n",
    "pyplot.plot([panel.xc for panel in panels if panel.loc == 'upper'],\n",
    "            [panel.cp for panel in panels if panel.loc == 'upper'],\n",
    "            label='upper',\n",
    "            color='r', linewidth=1, marker='x', markersize=8)\n",
    "pyplot.plot([panel.xc for panel in panels if panel.loc == 'lower'],\n",
    "            [panel.cp for panel in panels if panel.loc == 'lower'],\n",
    "            label='lower',\n",
    "            color='b', linewidth=0, marker='d', markersize=6)\n",
    "pyplot.plot(xtheo, 1-voverVsquared,\n",
    "            label='theoretical',\n",
    "            color='k', linestyle='--',linewidth=2)\n",
    "pyplot.legend(loc='best', prop={'size':14})\n",
    "pyplot.xlim(-0.1, 1.1)\n",
    "pyplot.ylim(1.0, -0.6)\n",
    "pyplot.title('Number of panels : {}'.format(N));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That looks pretty good! The only place where the panel method doesn't quite match the tabulated data from Theordorsen's method is at the trailing edge. But note that the flow-tangency boundary condition in the panel method is applied at the control point of the panel (not at the endpoints), so this discrepancy is not surprising."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Accuracy check"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For a closed body, the sum of all the source strengths must be zero. If not, it means the body would be adding or absorbing mass from the flow! Therefore, we should have\n",
    "\n",
    "$$\n",
    "\\sum_{j=1}^{N} \\sigma_j l_j = 0\n",
    "$$\n",
    "\n",
    "where $l_j$ is the length of the $j^{\\text{th}}$ panel.\n",
    "\n",
    "With this, we can get a get an idea of the accuracy of the source panel method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--> sum of source/sink strengths: 0.004617031175283089\n"
     ]
    }
   ],
   "source": [
    "# calculate the accuracy\n",
    "accuracy = sum([panel.sigma*panel.length for panel in panels])\n",
    "print('--> sum of source/sink strengths: {}'.format(accuracy))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Streamlines onto a mesh grid"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To get a streamline plot, we have to create a mesh (like we've done in all *AeroPython* lessons!) and compute the velocity field onto it. Knowing the strength of every panel, we find the $x$-component of the velocity by taking derivative of the velocity potential in the $x$-direction, and the $y$-component by taking derivative in the $y$-direction:\n",
    "\n",
    "$$\n",
    "u\\left(x,y\\right) = \\frac{\\partial}{\\partial x}\\left\\lbrace \\phi\\left(x,y\\right) \\right\\rbrace\n",
    "$$\n",
    "\n",
    "$$\n",
    "v\\left(x,y\\right) = \\frac{\\partial}{\\partial y}\\left\\lbrace \\phi\\left(x,y\\right) \\right\\rbrace\n",
    "$$\n",
    "\n",
    "Notice that here we call the function `integral()` with $1,0$ as the final arguments when calculating the derivatives in the $x$-direction, and $0,1$ for the derivatives in th $y$-direction.\n",
    "\n",
    "In addition, we use the function `numpy.vectorize()` (as we did in [Lesson 8](08_Lesson08_sourceSheet.ipynb)) to avoid the nested loops over the domain."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_velocity_field(panels, freestream, X, Y):\n",
    "    \"\"\"\n",
    "    Computes the velocity field on a given 2D mesh.\n",
    "    \n",
    "    Parameters\n",
    "    ---------\n",
    "    panels: 1D array of Panel objects\n",
    "        The source panels.\n",
    "    freestream: Freestream object\n",
    "        The freestream conditions.\n",
    "    X: 2D Numpy array of floats\n",
    "        x-coordinates of the mesh points.\n",
    "    Y: 2D Numpy array of floats\n",
    "        y-coordinate of the mesh points.\n",
    "    \n",
    "    Returns\n",
    "    -------\n",
    "    u: 2D Numpy array of floats\n",
    "        x-component of the velocity vector field.\n",
    "    v: 2D Numpy array of floats\n",
    "        y-component of the velocity vector field.\n",
    "    \"\"\"\n",
    "    # freestream contribution\n",
    "    u = freestream.u_inf * math.cos(freestream.alpha) * numpy.ones_like(X, dtype=float)\n",
    "    v = freestream.u_inf * math.sin(freestream.alpha) * numpy.ones_like(X, dtype=float)\n",
    "    # add the contribution from each source (superposition powers!!!)\n",
    "    vec_intregral = numpy.vectorize(integral)\n",
    "    for panel in panels:\n",
    "        u += panel.sigma / (2.0 * math.pi) * vec_intregral(X, Y, panel, 1.0, 0.0)\n",
    "        v += panel.sigma / (2.0 * math.pi) * vec_intregral(X, Y, panel, 0.0, 1.0)\n",
    "    \n",
    "    return u, v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# define a mesh grid\n",
    "nx, ny = 20, 20  # number of points in the x and y directions\n",
    "x_start, x_end = -1.0, 2.0\n",
    "y_start, y_end = -0.3, 0.3\n",
    "X, Y = numpy.meshgrid(numpy.linspace(x_start, x_end, nx),\n",
    "                      numpy.linspace(y_start, y_end, ny))\n",
    "\n",
    "# compute the velocity field on the mesh grid\n",
    "u, v = get_velocity_field(panels, freestream, X, Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the velocity field\n",
    "width = 10\n",
    "pyplot.figure(figsize=(width, width))\n",
    "pyplot.xlabel('x', fontsize=16)\n",
    "pyplot.ylabel('y', fontsize=16)\n",
    "pyplot.streamplot(X, Y, u, v,\n",
    "                  density=1, linewidth=1, arrowsize=1, arrowstyle='->')\n",
    "pyplot.fill([panel.xc for panel in panels],\n",
    "            [panel.yc for panel in panels],\n",
    "            color='k', linestyle='solid', linewidth=2, zorder=2)\n",
    "pyplot.axis('scaled', adjustable='box')\n",
    "pyplot.xlim(x_start, x_end)\n",
    "pyplot.ylim(y_start, y_end)\n",
    "pyplot.title('Streamlines around a NACA 0012 airfoil (AoA = ${}^o$)'.format(alpha),\n",
    "             fontsize=16);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now calculate the pressure coefficient. In Lesson 9, we computed the pressure coefficient on the surface of the circular cylinder. That was useful because we have an analytical solution for the surface pressure on a cylinder in potential flow. For an airfoil, we are interested to see how the pressure looks all around it, and we make a contour plot in the flow domain."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# compute the pressure field\n",
    "cp = 1.0 - (u**2 + v**2) / freestream.u_inf**2\n",
    "\n",
    "# plot the pressure field\n",
    "width = 10\n",
    "pyplot.figure(figsize=(width, width))\n",
    "pyplot.xlabel('x', fontsize=16)\n",
    "pyplot.ylabel('y', fontsize=16)\n",
    "contf = pyplot.contourf(X, Y, cp,\n",
    "                        levels=numpy.linspace(-2.0, 1.0, 100), extend='both')\n",
    "cbar = pyplot.colorbar(contf,\n",
    "                       orientation='horizontal',\n",
    "                       shrink=0.5, pad = 0.1,\n",
    "                       ticks=[-2.0, -1.0, 0.0, 1.0])\n",
    "cbar.set_label('$C_p$', fontsize=16)\n",
    "pyplot.fill([panel.xc for panel in panels],\n",
    "            [panel.yc for panel in panels],\n",
    "            color='k', linestyle='solid', linewidth=2, zorder=2)\n",
    "pyplot.axis('scaled', adjustable='box')\n",
    "pyplot.xlim(x_start, x_end)\n",
    "pyplot.ylim(y_start, y_end)\n",
    "pyplot.title('Contour of pressure field', fontsize=16);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Final words\n",
    "\n",
    "We've learned to use a source-sheet to represent any solid body: first a [circular cylinder](09_Lesson09_flowOverCylinder.ipynb) (which we knew we could get by superposing a doublet and a freestream), and now an airfoil.\n",
    "\n",
    "But what is the feature of airfoils that makes them interesting? Well, the fact that we can use them to generate lift and make things that fly, of course! But what do we need to generate lift? Think, think ... what is it?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## References"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. [Airfoil Tools](http://airfoiltools.com/index), website providing airfoil data.\n",
    "1. Ira Herbert Abbott, Albert Edward Von Doenhoff and Louis S. Stivers, Jr. (1945), \"Summary of Airfoil Data,\" NACA Report No.824, [PDF on the NASA web server](http://ntrs.nasa.gov/archive/nasa/casi.ntrs.nasa.gov/19930090976.pdf) (see p. 71)\n",
    "1. Ira Herbert Abbott, Albert Edward Von Doenhoff, \"Theory of Wing Sections, Including a Summary of Airfoil Data\" (1949), Dover Press. \n",
    "\n",
    "A further reference on Theodorsen's method is:\n",
    "\n",
    "* Roland Schinzinger, Patricio A. A. Laura (1991), \"Conformal Mapping: Methods and Applications.\" Dover edition in 2003. [Read on Google Books](https://books.google.com/books?id=qe-7AQAAQBAJ&lpg=PA128&ots=wbg0jLlqq5&dq=method%20theodorsen&pg=PA128#v=onepage&q=%22method%20of%20theodorsen%20and%20garrick%22&f=false)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "###### Please ignore the cell below. It just loads our style for the notebook."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<link href='http://fonts.googleapis.com/css?family=Fenix' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Alegreya+Sans:100,300,400,500,700,800,900,100italic,300italic,400italic,500italic,700italic,800italic,900italic' rel='stylesheet' type='text/css'>\n",
       "<link href='http://fonts.googleapis.com/css?family=Source+Code+Pro:300,400' rel='stylesheet' type='text/css'>\n",
       "<style>\n",
       "\n",
       "@font-face {\n",
       "    font-family: \"Computer Modern\";\n",
       "    src: url('http://mirrors.ctan.org/fonts/cm-unicode/fonts/otf/cmunss.otf');\n",
       "}\n",
       "\n",
       "\n",
       "#notebook_panel { /* main background */\n",
       "    background: rgb(245,245,245);\n",
       "}\n",
       "\n",
       "div.cell { /* set cell width */\n",
       "    width: 750px;\n",
       "}\n",
       "\n",
       "div #notebook { /* centre the content */\n",
       "    background: #fff; /* white background for content */\n",
       "    width: 1000px;\n",
       "    margin: auto;\n",
       "    padding-left: 0em;\n",
       "}\n",
       "\n",
       "#notebook li { /* More space between bullet points */\n",
       "margin-top:0.8em;\n",
       "}\n",
       "\n",
       "/* draw border around running cells */\n",
       "div.cell.border-box-sizing.code_cell.running { \n",
       "    border: 1px solid #111;\n",
       "}\n",
       "\n",
       "/* Put a solid color box around each cell and its output, visually linking them*/\n",
       "div.cell.code_cell {\n",
       "    background-color: rgb(256,256,256); \n",
       "    border-radius: 0px; \n",
       "    padding: 0.5em;\n",
       "    margin-left:1em;\n",
       "    margin-top: 1em;\n",
       "}\n",
       "\n",
       "\n",
       "div.text_cell_render{\n",
       "    font-family: 'Alegreya Sans' sans-serif;\n",
       "    line-height: 140%;\n",
       "    font-size: 125%;\n",
       "    font-weight: 400;\n",
       "    width:600px;\n",
       "    margin-left:auto;\n",
       "    margin-right:auto;\n",
       "}\n",
       "\n",
       "/* Formatting for header cells */\n",
       ".text_cell_render h1 {\n",
       "    font-family: 'Alegreya Sans', sans-serif;\n",
       "    font-style:regular;\n",
       "    font-weight: 200;    \n",
       "    font-size: 50pt;\n",
       "    line-height: 100%;\n",
       "    color:#CD2305;\n",
       "    margin-bottom: 0.5em;\n",
       "    margin-top: 0.5em;\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".text_cell_render h2 {\n",
       "    font-family: 'Fenix', serif;\n",
       "    font-size: 22pt;\n",
       "    line-height: 100%;\n",
       "    margin-bottom: 0.1em;\n",
       "    margin-top: 0.3em;\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".text_cell_render h3 {\n",
       "    font-family: 'Fenix', serif;\n",
       "    margin-top:12px;\n",
       "    font-size: 16pt;\n",
       "    margin-bottom: 3px;\n",
       "    font-style: regular;\n",
       "}\n",
       "\n",
       ".text_cell_render h4 {    /*Use this for captions*/\n",
       "    font-family: 'Fenix', serif;\n",
       "    font-size: 2pt;\n",
       "    text-align: center;\n",
       "    margin-top: 0em;\n",
       "    margin-bottom: 2em;\n",
       "    font-style: regular;\n",
       "}\n",
       "\n",
       ".text_cell_render h5 {  /*Use this for small titles*/\n",
       "    font-family: 'Alegreya Sans', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 16pt;\n",
       "    color: #CD2305;\n",
       "    font-style: italic;\n",
       "    margin-bottom: .5em;\n",
       "    margin-top: 0.5em;\n",
       "    display: block;\n",
       "}\n",
       "\n",
       ".text_cell_render h6 { /*use this for copyright note*/\n",
       "    font-family: 'Source Code Pro', sans-serif;\n",
       "    font-weight: 300;\n",
       "    font-size: 9pt;\n",
       "    line-height: 100%;\n",
       "    color: grey;\n",
       "    margin-bottom: 1px;\n",
       "    margin-top: 1px;\n",
       "}\n",
       "\n",
       ".CodeMirror{\n",
       "        font-family: \"Source Code Pro\";\n",
       "        font-size: 90%;\n",
       "}\n",
       "\n",
       ".warning{\n",
       "    color: rgb( 240, 20, 20 )\n",
       "    }\n",
       "</style>\n",
       "\n",
       "<script>\n",
       "    MathJax.Hub.Config({\n",
       "                        TeX: {\n",
       "                           extensions: [\"AMSmath.js\"], \n",
       "                           equationNumbers: { autoNumber: \"AMS\", useLabelIds: true}\n",
       "                           },\n",
       "                        tex2jax: {\n",
       "                            inlineMath: [ ['$','$'], [\"\\\\(\",\"\\\\)\"] ],\n",
       "                            displayMath: [ ['$$','$$'], [\"\\\\[\",\"\\\\]\"] ]\n",
       "                            },\n",
       "                        displayAlign: 'center', // Change this to 'center' to center equations.\n",
       "                        \"HTML-CSS\": {\n",
       "                            styles: {'.MathJax_Display': {\"margin\": 4}}\n",
       "                            }\n",
       "                        });\n",
       "    MathJax.Hub.Queue(\n",
       "                      [\"resetEquationNumbers\", MathJax.InputJax.TeX],\n",
       "                      [\"PreProcess\", MathJax.Hub],\n",
       "                      [\"Reprocess\", MathJax.Hub]\n",
       "                     );\n",
       "</script>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.core.display import HTML\n",
    "def css_styling(filepath):\n",
    "    styles = open(filepath, 'r').read()\n",
    "    return HTML(styles)\n",
    "css_styling('../styles/custom.css')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
